home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.5 Applications 2004 April / SGI IRIX 6.5 Applications 2004 April.iso / dist / mpi.idb / usr / share / catman / p_man / cat1 / MPI.z.z / MPI.z / MPI
Text File  |  2003-06-17  |  101KB  |  1,783 lines

  1.  
  2.  
  3.  
  4. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  5.  
  6.  
  7.  
  8. NNNNAAAAMMMMEEEE
  9.      MMMMPPPPIIII - Introduction to the Message Passing Interface (MPI)
  10.  
  11. DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
  12.      The Message Passing Interface (MPI) is a component of the Message Passing
  13.      Toolkit (MPT), which is a software package that supports parallel
  14.      programming across a network of computer systems through a technique
  15.      known as message passing.  The goal of MPI, simply stated, is to develop
  16.      a widely used standard for writing message-passing programs. As such, the
  17.      interface establishes a practical, portable, efficient, and flexible
  18.      standard for message passing.
  19.  
  20.      This MPI implementation supports the MPI 1.2 standard, as documented by
  21.      the MPI Forum in the spring 1997 release of _M_P_I: _A _M_e_s_s_a_g_e _P_a_s_s_i_n_g
  22.      _I_n_t_e_r_f_a_c_e _S_t_a_n_d_a_r_d.  In addition, certain MPI-2 features are also
  23.      supported.  In designing MPI, the MPI Forum sought to make use of the
  24.      most attractive features of a number of existing message passing systems,
  25.      rather than selecting one of them and adopting it as the standard.  Thus,
  26.      MPI has been strongly influenced by work at the IBM T. J. Watson Research
  27.      Center, Intel's NX/2, Express, nCUBE's Vertex, p4, and PARMACS. Other
  28.      important contributions have come from Zipcode, Chimp, PVM, Chameleon,
  29.      and PICL.
  30.  
  31.      MPI requires the presence of an Array Services daemon (aaaarrrrrrrraaaayyyydddd) on each
  32.      host that is to run MPI processes. In a single-host environment, no
  33.      system administration effort should be required beyond installing and
  34.      activating aaaarrrrrrrraaaayyyydddd. However, users wishing to run MPI applications across
  35.      multiple hosts will need to ensure that those hosts are properly
  36.      configured into an array.  For more information about Array Services, see
  37.      the aaaarrrrrrrraaaayyyydddd(1M), aaaarrrrrrrraaaayyyydddd....ccccoooonnnnffff(4), and aaaarrrrrrrraaaayyyy____sssseeeerrrrvvvviiiicccceeeessss(5) man pages.
  38.  
  39.      When running across multiple hosts, users must set up their ....rrrrhhhhoooossssttttssss files
  40.      to enable remote logins. Note that MPI does not use rrrrsssshhhh, so it is not
  41.      necessary that rrrrsssshhhhdddd be running on security-sensitive systems; the ....rrrrhhhhoooossssttttssss
  42.      file was simply chosen to eliminate the need to learn yet another
  43.      mechanism for enabling remote logins.
  44.  
  45.      Other sources of MPI information are as follows:
  46.  
  47.      *   Man pages for MPI library functions
  48.  
  49.      *   A copy of the MPI standard as PostScript or hypertext on the World
  50.          Wide Web at the following URL:
  51.  
  52.               hhhhttttttttpppp::::////////wwwwwwwwwwww....mmmmppppiiii----ffffoooorrrruuuummmm....oooorrrrgggg////
  53.  
  54.  
  55.      *   Other MPI resources on the World Wide Web, such as the following:
  56.  
  57.               hhhhttttttttpppp::::////////wwwwwwwwwwww....mmmmccccssss....aaaannnnllll....ggggoooovvvv////mmmmppppiiii////iiiinnnnddddeeeexxxx....hhhhttttmmmmllll
  58.               hhhhttttttttpppp::::////////wwwwwwwwwwww....eeeerrrrcccc....mmmmssssssssttttaaaatttteeee....eeeedddduuuu////mmmmppppiiii////iiiinnnnddddeeeexxxx....hhhhttttmmmmllll
  59.               hhhhttttttttpppp::::////////wwwwwwwwwwww....mmmmppppiiii....nnnndddd....eeeedddduuuu////llllaaaammmm////
  60.  
  61.  
  62.  
  63.                                                                         PPPPaaaaggggeeee 1111
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  71.  
  72.  
  73.  
  74.    GGGGeeeettttttttiiiinnnngggg SSSSttttaaaarrrrtttteeeedddd
  75.      For IRIX systems, the MMMMoooodddduuuulllleeeessss software package is available to support
  76.      one or more installations of MPT.  To use the MPT software, load the
  77.      desired mmmmpppptttt module.
  78.  
  79.      After you have initialized modules, enter the following command:
  80.  
  81.           mmmmoooodddduuuulllleeee llllooooaaaadddd mmmmpppptttt
  82.  
  83.  
  84.      To unload the mmmmpppptttt module, enter the following command:
  85.  
  86.           mmmmoooodddduuuulllleeee uuuunnnnllllooooaaaadddd mmmmpppptttt
  87.  
  88.  
  89.      MPT software can be installed in an alternate location for use with the
  90.      modules software package.  If MPT software has been installed on your
  91.      system for use with modules, you can access the software with the mmmmoooodddduuuulllleeee
  92.      command shown in the previous example.  If MPT has not been installed for
  93.      use with modules, the software resides in default locations on your
  94.      system (////uuuussssrrrr////iiiinnnncccclllluuuuddddeeee, ////uuuussssrrrr////lllliiiibbbb, /usr/array/PVM, and so on), as in
  95.      previous releases.  For further information, see IIIInnnnssssttttaaaalllllllliiiinnnngggg MMMMPPPPTTTT ffffoooorrrr UUUUsssseeee
  96.      wwwwiiiitttthhhh MMMMoooodddduuuulllleeeessss, in the Modules relnotes.
  97.  
  98.  
  99.    UUUUssssiiiinnnngggg MMMMPPPPIIII
  100.      Compile and link your MPI program as shown in the following examples.
  101.  
  102.      IRIX systems:
  103.  
  104.      To use the 64-bit MPI library, choose one of the following commands:
  105.  
  106.           cccccccc ----66664444 ccccoooommmmppppuuuutttteeee....cccc ----llllmmmmppppiiii
  107.           ffff77777777 ----66664444 ----LLLLAAAANNNNGGGG::::rrrreeeeccccuuuurrrrssssiiiivvvveeee====oooonnnn ccccoooommmmppppuuuutttteeee....ffff ----llllmmmmppppiiii
  108.           ffff99990000 ----66664444 ----LLLLAAAANNNNGGGG::::rrrreeeeccccuuuurrrrssssiiiivvvveeee====oooonnnn ccccoooommmmppppuuuutttteeee....ffff ----llllmmmmppppiiii
  109.           CCCCCCCC ----66664444 ccccoooommmmppppuuuutttteeee....CCCC ----llllmmmmppppiiii++++++++ ----llllmmmmppppiiii
  110.  
  111.  
  112.      To use the 32-bit MPI library, choose one of the following commands:
  113.  
  114.           cccccccc ----nnnn33332222 ccccoooommmmppppuuuutttteeee....cccc ----llllmmmmppppiiii
  115.           ffff77777777 ----nnnn33332222 ----LLLLAAAANNNNGGGG::::rrrreeeeccccuuuurrrrssssiiiivvvveeee====oooonnnn ccccoooommmmppppuuuutttteeee....ffff ----llllmmmmppppiiii
  116.           ffff99990000 ----nnnn33332222 ----LLLLAAAANNNNGGGG::::rrrreeeeccccuuuurrrrssssiiiivvvveeee====oooonnnn ccccoooommmmppppuuuutttteeee....ffff ----llllmmmmppppiiii
  117.           CCCCCCCC ----nnnn33332222 ccccoooommmmppppuuuutttteeee....CCCC ----llllmmmmppppiiii++++++++ ----llllmmmmppppiiii
  118.  
  119.  
  120.      Linux systems:
  121.  
  122.      To use the 64-bit MPI library on Linux IA64 systems, choose one of the
  123.      following commands:
  124.  
  125.  
  126.  
  127.  
  128.  
  129.                                                                         PPPPaaaaggggeeee 2222
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  137.  
  138.  
  139.  
  140.           gggg++++++++ ----oooo mmmmyyyypppprrrroooogggg mmmmyyyypppprrrroooocccc....CCCC ----llllmmmmppppiiii++++++++ ----llllmmmmppppiiii
  141.           ggggcccccccc ----oooo mmmmyyyypppprrrroooogggg mmmmyyyypppprrrroooogggg....cccc ----llllmmmmppppiiii
  142.  
  143.  
  144.      For IRIX systems, if Fortran 90 compiler 7.2.1 or higher is installed,
  145.      you can add the ----aaaauuuuttttoooo____uuuusssseeee option as follows to get compile-time checking
  146.      of MPI subroutine calls:
  147.  
  148.           ffff99990000 ----aaaauuuuttttoooo____uuuusssseeee mmmmppppiiii____iiiinnnntttteeeerrrrffffaaaacccceeee ----66664444 ccccoooommmmppppuuuutttteeee....ffff ----llllmmmmppppiiii
  149.           ffff99990000 ----aaaauuuuttttoooo____uuuusssseeee mmmmppppiiii____iiiinnnntttteeeerrrrffffaaaacccceeee ----nnnn33332222 ccccoooommmmppppuuuutttteeee....ffff ----llllmmmmppppiiii
  150.  
  151.  
  152.      For IRIX with MPT version 1.4 or higher, the Fortran 90 UUUUSSSSEEEE MMMMPPPPIIII feature
  153.      is supported.  You can replace the iiiinnnncccclllluuuuddddeeee ''''mmmmppppiiiiffff....hhhh'''' statement in your
  154.      Fortran 90 source code with UUUUSSSSEEEE MMMMPPPPIIII.  This facility includes MPI type and
  155.      parameter definitions, and performs compile-time checking of MPI function
  156.      and subroutine calls.
  157.  
  158.      NOTE:  Do not use the Fortran 90 ----aaaauuuuttttoooo____uuuusssseeee mmmmppppiiii____iiiinnnntttteeeerrrrffffaaaacccceeee option to
  159.      compile IRIX Fortran 90 source code that contains the UUUUSSSSEEEE MMMMPPPPIIII statement.
  160.      They are incompatible with each other.
  161.  
  162.      For IRIX systems, applications compiled under a previous release of MPI
  163.      should not require recompilation to run under this new (3.3) release.
  164.      However, it is not possible for executable files running under the 3.2
  165.      release to interoperate with others running under the 3.3 release.
  166.  
  167.      The C version of the MMMMPPPPIIII____IIIInnnniiiitttt(3) routine ignores the arguments that are
  168.      passed to it and does not modify them.
  169.  
  170.      SSSSttttddddiiiinnnn is enabled only for those MPI processes with rank 0 in the first
  171.      MMMMPPPPIIII____CCCCOOOOMMMMMMMM____WWWWOOOORRRRLLLLDDDD (which does not need to be located on the same host as
  172.      mmmmppppiiiirrrruuuunnnn).  SSSSttttddddoooouuuutttt and ssssttttddddeeeerrrrrrrr results are enabled for all MPI processes in
  173.      the job, whether launched via mmmmppppiiiirrrruuuunnnn, or one of the MPI-2 spawn
  174.      functions.
  175.  
  176.  
  177.      This version of the IRIX MPI implementation is compatible with the sssspppprrrroooocccc
  178.      system call and can therefore coexist with ddddooooaaaaccccrrrroooossssssss loops.  SGI MPI can
  179.      likewise coexist with OpenMP on Linux systems. By default MPI is not
  180.      threadsafe.  Therefore, calls to MPI routines in a multithreaded
  181.      application will require some form of mutual exclusion.  The
  182.      MMMMPPPPIIII____IIIInnnniiiitttt____tttthhhhrrrreeeeaaaadddd call can be used to request thread safety.  In this case,
  183.      MPI calls can be made within parallel regions.  MMMMPPPPIIII____IIIInnnniiiitttt____tttthhhhrrrreeeeaaaadddd is
  184.      available on IRIX only.
  185.  
  186.      For IRIX and Linux systems, this implementation of MPI requires that all
  187.      MPI processes call MMMMPPPPIIII____FFFFiiiinnnnaaaalllliiiizzzzeeee eventually.
  188.  
  189.  
  190.  
  191.  
  192.  
  193.  
  194.  
  195.                                                                         PPPPaaaaggggeeee 3333
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  203.  
  204.  
  205.  
  206.    BBBBuuuuffffffffeeeerrrriiiinnnngggg
  207.      The current implementation buffers messages unless the MMMMPPPPIIII____BBBBUUUUFFFFFFFFEEEERRRR____MMMMAAAAXXXX
  208.      environment variable is set.
  209.  
  210.      Buffered messages are grouped into two classes based on length: short
  211.      (messages with lengths of 64 bytes or less) and long (messages with
  212.      lengths greater than 64 bytes).
  213.  
  214.      When MMMMPPPPIIII____BBBBUUUUFFFFFFFFEEEERRRR____MMMMAAAAXXXX is set, messages greater than this value are
  215.      candidates for single-copy transfers.  For IRIX systems, the data from
  216.      the sending process must reside in the symmetric data, symmetric heap, or
  217.      global heap segment and be a contiguous type.  For Linux systems, the
  218.      data from the sending process can reside in the static region, stack, or
  219.      private heap and must be a contiguous type.
  220.  
  221.      For more information on single-copy transfers, see the MMMMPPPPIIII____BBBBUUUUFFFFFFFFEEEERRRR____MMMMAAAAXXXX
  222.      environment variable.
  223.  
  224.  
  225.    MMMMyyyyrrrriiiinnnneeeetttt ((((GGGGMMMM)))) SSSSuuuuppppppppoooorrrrtttt
  226.      This release provides support for use of the GM protocol over Myrinet
  227.      interconnects on IRIX systems. Support is currently limited to 64-bit
  228.      applications.
  229.  
  230.  
  231.    UUUUssssiiiinnnngggg MMMMPPPPIIII wwwwiiiitttthhhh ccccppppuuuusssseeeettttssss
  232.      You can use cpusets to run MPI applications (see ccccppppuuuusssseeeetttt(4)).  However, it
  233.      is highly recommended that the cpuset have the MMMMEEEEMMMMOOOORRRRYYYY____LLLLOOOOCCCCAAAALLLL attribute.
  234.      On Origin systems, if this attribute is not used, you should disable NUMA
  235.      optimizations (see the MMMMPPPPIIII____DDDDSSSSMMMM____OOOOFFFFFFFF environment variable description in
  236.      the following section).
  237.  
  238.  
  239.    DDDDeeeeffffaaaauuuulllltttt IIIInnnntttteeeerrrrccccoooonnnnnnnneeeecccctttt SSSSeeeelllleeeeccccttttiiiioooonnnn
  240.      Beginning with the MPT 1.6 release, the search algorithm for selecting a
  241.      multi-host interconnect has been significantly modified.  By default, if
  242.      MPI is being run across multiple hosts, or if multiple binaries are
  243.      specified on the mmmmppppiiiirrrruuuunnnn command, the software now searches for
  244.      interconnects in the following order (for IRIX systems):
  245.  
  246.           1) XPMEM (NUMAlink - only available on partitioned systems)
  247.           2) GSN
  248.           3) MYRINET
  249.           4) HIPPI 800
  250.           5) TCP/IP
  251.  
  252.      The only supported interconnects on Linux systems are XPMEM and TCP/IP.
  253.  
  254.      MPI uses the first interconnect it can detect and configure correctly.
  255.      There will only be one interconnect configured for the entire MPI job,
  256.      with the exception of XPMEM.  If XPMEM is found on some hosts, but not on
  257.      others, one additional interconnect is selected.
  258.  
  259.  
  260.  
  261.                                                                         PPPPaaaaggggeeee 4444
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  269.  
  270.  
  271.  
  272.      The user can specify a mandatory interconnect to use by setting one of
  273.      the following new environment variables.  These variables will be
  274.      assessed in the following order:
  275.  
  276.           1) MPI_USE_XPMEM
  277.           2) MPI_USE_GSN
  278.           3) MPI_USE_GM
  279.           4) MPI_USE_HIPPI
  280.           5) MPI_USE_TCP
  281.  
  282.      For a mandatory interconnect to be used, all of the hosts on the mmmmppppiiiirrrruuuunnnn
  283.      command line must be connected via the device, and the interconnect must
  284.      be configured properly.  If this is not the case, an error message is
  285.      printed to stdout and the job is terminated.  XPMEM is an exception to
  286.      this rule, however.
  287.  
  288.      If MMMMPPPPIIII____UUUUSSSSEEEE____XXXXPPPPMMMMEEEEMMMM is set, one additional interconnect can be selected via
  289.      the MMMMPPPPIIII____UUUUSSSSEEEE variables.  Messaging between the partitioned hosts will use
  290.      the XPMEM driver while messaging between non-partitioned hosts will use
  291.      the second interconnect.  If a second interconnect is required but not
  292.      selected by the user, MPI will choose the interconnect to use, based on
  293.      the default hierarchy.
  294.  
  295.      If the global ----vvvv verbose option is used on the mmmmppppiiiirrrruuuunnnn command line, a
  296.      message is printed to stdout, indicating which multi-host interconnect is
  297.      being used for the job.
  298.  
  299.      The following interconnect selection environment variables have been
  300.      deprecated in the MPT 1.6 release: MMMMPPPPIIII____GGGGSSSSNNNN____OOOONNNN, MMMMPPPPIIII____GGGGMMMM____OOOONNNN, and
  301.      MMMMPPPPIIII____BBBBYYYYPPPPAAAASSSSSSSS____OOOOFFFFFFFF.  If any of these variables are set, MPI prints a warning
  302.      message to stdout. The meanings of these variables are ignored.
  303.  
  304.  
  305.    UUUUssssiiiinnnngggg MMMMPPPPIIII----2222 PPPPrrrroooocccceeeessssssss CCCCrrrreeeeaaaattttiiiioooonnnn aaaannnndddd MMMMaaaannnnaaaaggggeeeemmmmeeeennnntttt RRRRoooouuuuttttiiiinnnneeeessss
  306.      This release provides support for MMMMPPPPIIII____CCCCoooommmmmmmm____ssssppppaaaawwwwnnnn and
  307.      MMMMPPPPIIII____CCCCoooommmmmmmm____ssssppppaaaawwwwnnnn____mmmmuuuullllttttiiiipppplllleeee on IRIX systems.  However, options must be
  308.      included on the mmmmppppiiiirrrruuuunnnn command line to enable this feature.  When these
  309.      options are present on the mmmmppppiiiirrrruuuunnnn command line, the MMMMPPPPIIII job is running in
  310.      spawn capable mode.  In this release, these spawn features are only
  311.      available for jobs confined to a single IRIX host.
  312.  
  313.  
  314. EEEENNNNVVVVIIIIRRRROOOONNNNMMMMEEEENNNNTTTT VVVVAAAARRRRIIIIAAAABBBBLLLLEEEESSSS
  315.      This section describes the variables that specify the environment under
  316.      which your MPI programs will run. Unless otherwise specified, these
  317.      variables are available for both Linux and IRIX systems.  Environment
  318.      variables have predefined values.  You can change some variables to
  319.      achieve particular performance objectives; others are required values for
  320.      standard-compliant programs.
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327.                                                                         PPPPaaaaggggeeee 5555
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  335.  
  336.  
  337.  
  338.      MMMMPPPPIIII____AAAARRRRRRRRAAAAYYYY
  339.           Sets an alternative array name to be used for communicating with
  340.           Array Services when a job is being launched.
  341.  
  342.           Default:  The default name set in the aaaarrrrrrrraaaayyyydddd....ccccoooonnnnffff file
  343.  
  344.      MMMMPPPPIIII____BBBBAAAARRRR____CCCCOOOOUUUUNNNNTTTTEEEERRRR (IRIX systems only)
  345.           Specifies the use of a simple counter barrier algorithm within the
  346.           MMMMPPPPIIII____BBBBaaaarrrrrrrriiiieeeerrrr(3) and MMMMPPPPIIII____WWWWiiiinnnn____ffffeeeennnncccceeee(3) functions.
  347.  
  348.           Default:  Enabled for jobs using fewer than 64 MPI processes.
  349.  
  350.      MMMMPPPPIIII____BBBBAAAARRRR____DDDDIIIISSSSSSSSEEEEMMMM
  351.           Specifies the use of of a dissemination/butterfly algorithm within
  352.           the MMMMPPPPIIII____BBBBaaaarrrrrrrriiiieeeerrrr(3) and MMMMPPPPIIII____WWWWiiiinnnn____ffffeeeennnncccceeee(3) functions. This algorithm
  353.           has generally been found to provide the best performance.  By
  354.           default on IRIX systems this algorithm is used for MPI_COMM_WORLD
  355.           and congruent communicators.  Explicitly specifying this environment
  356.           variable also enables the use of this algorithm for other
  357.           communicators on both IRIX and Linux systems.
  358.  
  359.           Default:  Enabled for MPI_COMM_WORLD for jobs using more than 64
  360.           processes(IRIX only).
  361.  
  362.      MMMMPPPPIIII____BBBBAAAARRRR____TTTTRRRREEEEEEEE
  363.           Specifies the use of a tree barrier within the MMMMPPPPIIII____BBBBaaaarrrrrrrriiiieeeerrrr(3) and
  364.           MMMMPPPPIIII____WWWWiiiinnnn____ffffeeeennnncccceeee(3) functions.   This variable can also be used to
  365.           change the default arity(fan-in) of the tree barrier algorithm.
  366.           Typically this barrier is slower than the butterfly/dissemination
  367.           barrier.
  368.  
  369.           Default:  Not enabled.  Default arity is 8 when enabled.
  370.  
  371.      MMMMPPPPIIII____BBBBUUUUFFFFFFFFEEEERRRR____MMMMAAAAXXXX
  372.           Specifies a minimum message size, in bytes, for which the message
  373.           will be considered a candidate for single-copy transfer.
  374.  
  375.           On IRIX, this mechanism is available only for communication between
  376.           MPI processes on the same host. The sender data must reside in
  377.           either the symmetric data, symmetric heap, or global heap. The MPI
  378.           data type on the send side must also be a contiguous type.
  379.  
  380.           On IRIX, if the XPMEM driver is enabled (for single host jobs, see
  381.           MMMMPPPPIIII____XXXXPPPPMMMMEEEEMMMM____OOOONNNN and for multihost jobs, see MMMMPPPPIIII____UUUUSSSSEEEE____XXXXPPPPMMMMEEEEMMMM), MPI allows
  382.           single-copy transfers for basic predefined MPI data types from any
  383.           sender data location, including the stack and private heap.  The
  384.           XPMEM driver also allows single-copy transfers across partitions.
  385.  
  386.           On IRIX, if cross mapping of data segments is enabled at job
  387.           startup, data in common blocks will reside in the symmetric data
  388.           segment.  On systems running IRIX 6.5.2 or higher, this feature is
  389.           enabled by default. You can employ the symmetric heap by using the
  390.  
  391.  
  392.  
  393.                                                                         PPPPaaaaggggeeee 6666
  394.  
  395.  
  396.  
  397.  
  398.  
  399.  
  400. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  401.  
  402.  
  403.  
  404.           sssshhhhmmmmaaaalllllllloooocccc(sssshhhhppppaaaalllllllloooocccc) functions available in LIBSMA.
  405.  
  406.           On Linux, this feature is supported for both single host MPI jobs
  407.           and MPI jobs running across partitions. MPI uses the xpmem module to
  408.           map memory from one MPI process onto another during job startup.
  409.           The mapped areas include the static region, private heap, and stack
  410.           region.  Single-copy is supported for contiguous data types from any
  411.           of the mapped regions.
  412.  
  413.           Memory mapping is enabled by default on Linux.  To disable it, set
  414.           the MMMMPPPPIIII____MMMMEEEEMMMMMMMMAAAAPPPP____OOOOFFFFFFFF environment variable.  In addition, the xpmem
  415.           kernel module must be installed on your system for single-copy
  416.           transfers. The xpmem module is released with the OS.
  417.  
  418.           Testing of this feature has indicated that most MPI applications
  419.           benefit more from buffering of medium-sized messages than from
  420.           buffering of large size messages, even though buffering of medium-
  421.           sized messages requires an extra copy of data.  However, highly
  422.           synchronized applications that perform large message transfers can
  423.           benefit from the single-copy pathway.
  424.  
  425.           Default:  Not enabled
  426.  
  427.      MMMMPPPPIIII____BBBBUUUUFFFFSSSS____PPPPEEEERRRR____HHHHOOOOSSSSTTTT
  428.           Determines the number of shared message buffers (16 KB each) that
  429.           MPI is to allocate for each host.  These buffers are used to send
  430.           long messages and interhost messages.
  431.  
  432.           Default:  32 pages (1 page = 16KB)
  433.  
  434.      MMMMPPPPIIII____BBBBUUUUFFFFSSSS____PPPPEEEERRRR____PPPPRRRROOOOCCCC
  435.           Determines the number of private message buffers (16 KB each) that
  436.           MPI is to allocate for each process.  These buffers are used to send
  437.           long messages and intrahost messages.
  438.  
  439.           Default:  32 pages (1 page = 16KB)
  440.  
  441.      MMMMPPPPIIII____BBBBYYYYPPPPAAAASSSSSSSS____CCCCRRRRCCCC (IRIX systems only)
  442.           Adds a checksum to each long message sent via HiPPI bypass.  If the
  443.           checksum does not match the data received, the job is terminated.
  444.           Use of this environment variable might degrade performance.
  445.  
  446.           Default:  Not set
  447.  
  448.      MMMMPPPPIIII____BBBBYYYYPPPPAAAASSSSSSSS____DDDDEEEEVVVV____SSSSEEEELLLLEEEECCCCTTTTIIIIOOOONNNN (IRIX systems only)
  449.           Specifies the algorithm MPI is to use for sending messages over
  450.           multiple HIPPI adapters.  Set this variable to one of the following
  451.           values:
  452.  
  453.                VVVVaaaalllluuuueeee          AAAAccccttttiiiioooonnnn
  454.  
  455.  
  456.  
  457.  
  458.  
  459.                                                                         PPPPaaaaggggeeee 7777
  460.  
  461.  
  462.  
  463.  
  464.  
  465.  
  466. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  467.  
  468.  
  469.  
  470.                0000              Static device selection. In this case, a process
  471.                               is assigned a HIPPI device to use for
  472.                               communication with processes on another host.
  473.                               The process uses only this HIPPI device to
  474.                               communicate with another host. This algorithm
  475.                               has been observed to be effective when interhost
  476.                               communication patterns are dominated by large
  477.                               messages (significantly more than 16K bytes).
  478.  
  479.                1111              Dynamic device selection. In this case, a
  480.                               process can select from any of the devices
  481.                               available for communication between any given
  482.                               pair of hosts. The first device that is not
  483.                               being used by another process is selected. This
  484.                               algorithm has been found to work best for
  485.                               applications in which multiple processes are
  486.                               trying to send medium-sized messages (16K or
  487.                               fewer bytes) between processes on different
  488.                               hosts. Large messages (more than 16K bytes) are
  489.                               split into chunks of 16K bytes. Different chunks
  490.                               can be sent over different HIPPI devices.
  491.  
  492.                2222              Round robin device selection. In this case, each
  493.                               process sends successive messages over a
  494.                               different HIPPI 800 device.
  495.  
  496.                               Default:  1
  497.  
  498.      MMMMPPPPIIII____BBBBYYYYPPPPAAAASSSSSSSS____DDDDEEEEVVVVSSSS (IRIX systems only)
  499.           Sets the order for opening HiPPI adapters. The list of devices does
  500.           not need to be space-delimited (0123 is valid).  A maximum of 16
  501.           adapters are supported on a single host.  To reference adapters 10
  502.           through 15, use the letters a through f or A through F,
  503.           respectively.
  504.  
  505.           An array node usually has at least one HiPPI adapter, the interface
  506.           to the HiPPI network.  The HiPPI bypass is a lower software layer
  507.           that interfaces directly to this adapter.
  508.  
  509.           When you know that a system has multiple HiPPI adapters, you can use
  510.           the MMMMPPPPIIII____BBBBYYYYPPPPAAAASSSSSSSS____DDDDEEEEVVVVSSSS variable to specify the adapter that a program
  511.           opens first. This variable can be used to ensure that multiple MPI
  512.           programs distribute their traffic across the available adapters.  If
  513.           you prefer not to use the HiPPI bypass, you can turn it off by
  514.           setting the MMMMPPPPIIII____BBBBYYYYPPPPAAAASSSSSSSS____OOOOFFFFFFFF variable.
  515.  
  516.           When a HiPPI adapter reaches its maximum capacity of four MPI
  517.           programs, it is not available to additional MPI programs. If all
  518.           HiPPI adapters are busy, MPI sends internode messages by using TCP
  519.           over the adapter instead of the bypass.
  520.  
  521.           Default:  MPI will use all available HiPPI devices
  522.  
  523.  
  524.  
  525.                                                                         PPPPaaaaggggeeee 8888
  526.  
  527.  
  528.  
  529.  
  530.  
  531.  
  532. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  533.  
  534.  
  535.  
  536.      MMMMPPPPIIII____BBBBYYYYPPPPAAAASSSSSSSS____SSSSIIIINNNNGGGGLLLLEEEE (IRIX systems only)
  537.           Allows MPI messages to be sent over multiple HiPPI connections if
  538.           multiple connections are available.  The HiPPI OS bypass multiboard
  539.           feature is enabled by default.  This environment variable disables
  540.           it.  When you set this variable, MPI operates as it did in previous
  541.           releases, with use of a single HiPPI adapter connection, if
  542.           available.
  543.  
  544.           Default:  Not enabled
  545.  
  546.      MMMMPPPPIIII____BBBBYYYYPPPPAAAASSSSSSSS____VVVVEEEERRRRBBBBOOOOSSSSEEEE (IRIX systems only)
  547.           Allows additional MPI initialization information to be printed in
  548.           the standard output stream.  This information contains details about
  549.           the HiPPI OS bypass connections and the HiPPI adapters that are
  550.           detected on each of the hosts.
  551.  
  552.           Default:  Not enabled
  553.  
  554.      MMMMPPPPIIII____CCCCHHHHEEEECCCCKKKK____AAAARRRRGGGGSSSS
  555.           Enables checking of MPI function arguments. Segmentation faults
  556.           might occur if bad arguments are passed to MPI, so this is useful
  557.           for debugging purposes.  Using argument checking adds several
  558.           microseconds to latency.
  559.  
  560.           Default:  Not enabled
  561.  
  562.      MMMMPPPPIIII____CCCCOOOOMMMMMMMM____MMMMAAAAXXXX
  563.           Sets the maximum number of communicators that can be used in an MPI
  564.           program.  Use this variable to increase internal default limits.
  565.           (Might be required by standard-compliant programs.)  MPI generates
  566.           an error message if this limit (or the default, if not set) is
  567.           exceeded.
  568.  
  569.           Default:  256
  570.  
  571.      MMMMPPPPIIII____CCCCOOOORRRREEEEDDDDUUUUMMMMPPPP
  572.           Controls which ranks of an MPI job can dump core on receipt of a
  573.           core-dumping signal.  Valid values are NNNNOOOONNNNEEEE, FFFFIIIIRRRRSSSSTTTT, AAAALLLLLLLL, or IIIINNNNHHHHIIIIBBBBIIIITTTT.
  574.           NNNNOOOONNNNEEEE means that no rank should dump core.  FFFFIIIIRRRRSSSSTTTT means that the
  575.           first rank on each host to receive a core-dumping signal should dump
  576.           core. AAAALLLLLLLL means that all ranks should dump core if they receive a
  577.           core-dumping signal.   IIIINNNNHHHHIIIIBBBBIIIITTTT disables MPI signal-handler
  578.           registration for core-dumping signals.
  579.  
  580.           When MMMMPPPPIIII____IIIInnnniiiitttt() is called, the MPI library attempts to register a
  581.           signal handler for each signal for which reception causes a core
  582.           dump. If a signal handler was previously registered, MPI removes the
  583.           MPI registration and restores the other signal handler for that
  584.           signal. If no previously-registered handler is present, the MPI
  585.           handler is invoked if and when the rank receives a core-dumping
  586.           signal.
  587.  
  588.  
  589.  
  590.  
  591.                                                                         PPPPaaaaggggeeee 9999
  592.  
  593.  
  594.  
  595.  
  596.  
  597.  
  598. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  599.  
  600.  
  601.  
  602.           When the MPI signal handler is invoked, it displays a stack
  603.           traceback for the first rank entering the handler on each host, and
  604.           then consults MMMMPPPPIIII____CCCCOOOORRRREEEEDDDDUUUUMMMMPPPP to determine if a core dump should be
  605.           produced.
  606.  
  607.           Note that process limits on core dump size interact with this
  608.           setting.  First a process decides to dump core or is inhibited from
  609.           dumping core based on the MMMMPPPPIIII____CCCCOOOORRRREEEEDDDDUUUUMMMMPPPP setting. Then "limit
  610.           coredump" applies to the resulting core dump file(s), if any.
  611.  
  612.           Default: FFFFIIIIRRRRSSSSTTTT
  613.  
  614.      MMMMPPPPIIII____CCCCOOOORRRREEEEDDDDUUUUMMMMPPPP____DDDDEEEEBBBBUUUUGGGGGGGGEEEERRRR (Linux only)
  615.           This variable lets you optionally specify which debugger should be
  616.           used by MPT to display the stack traceback when your program
  617.           receives a core-dumping signal.  Set MMMMPPPPIIII____VVVVEEEERRRRBBBBOOOOSSSSEEEE to have MPT display
  618.           the debugger command just before it executes it. If the environment
  619.           variable is not defined, MPT uses the iiiiddddbbbb debugger.
  620.  
  621.           You can specify this variable in any of the following formats:
  622.  
  623.                FFFFoooorrrrmmmmaaaatttt                   MMMMeeeeaaaannnniiiinnnngggg
  624.  
  625.                Basename of a debugger   If you specify iiiiddddbbbb or ggggddddbbbb, MPT uses
  626.                                         that debugger, customizing the command
  627.                                         line argument and debugger commands
  628.                                         sent to the debugger, as appropriate.
  629.  
  630.                                         Note that the program you specify must
  631.                                         be located in one of the directories
  632.                                         specified by the PPPPAAAATTTTHHHH environment
  633.                                         variable in the MPT job. This might be
  634.                                         different from the PPPPAAAATTTTHHHH variable in
  635.                                         your interactive sessions.  If you
  636.                                         receive a message similar to sssshhhh:::: iiiiddddbbbb::::
  637.                                         ccccoooommmmmmmmaaaannnndddd nnnnooootttt ffffoooouuuunnnndddd in the stack
  638.                                         traceback, you can use the pathname to
  639.                                         the debugger (described in the
  640.                                         following format) to supply a full
  641.                                         pathname instead.
  642.  
  643.                Pathname to a debugger   If you specify a value that contains a
  644.                                         ////, but no spaces, MPT takes the value
  645.                                         as the pathname to the debugger you
  646.                                         wish to use. The final four characters
  647.                                         of the value must be ////iiiiddddbbbb or ////ggggddddbbbb.
  648.                                         Command-line arguments are not
  649.                                         supplied to the debugger, but debugger
  650.                                         commands are customized according to
  651.                                         the debugger specified.  If you need
  652.                                         to specify command-line arguments to
  653.                                         the debugger, use a complete command
  654.  
  655.  
  656.  
  657.                                                                        PPPPaaaaggggeeee 11110000
  658.  
  659.  
  660.  
  661.  
  662.  
  663.  
  664. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  665.  
  666.  
  667.  
  668.                                         line (described in the following
  669.                                         format).
  670.  
  671.                Complete command line    If the value contains a space, it is
  672.                                         taken as the complete command line to
  673.                                         be passed to ssssyyyysssstttteeeemmmm(1).  Up to four
  674.                                         occurrences of %%%%dddd in the command line
  675.                                         are replaced by the process ID of the
  676.                                         process upon which the debugger should
  677.                                         be run.  You will need to arrange for
  678.                                         debugger commands to be sent to the
  679.                                         debugger.  The third and fourth
  680.                                         examples below show samples of this.
  681.  
  682.           Examples:  (There are four examples here, each of which must be
  683.           typed all on one line)
  684.  
  685.  
  686.           sssseeeetttteeeennnnvvvv MMMMPPPPIIII____CCCCOOOORRRREEEEDDDDUUUUMMMMPPPP____DDDDEEEEBBBBUUUUGGGGGGGGEEEERRRR ggggddddbbbb
  687.           sssseeeetttteeeennnnvvvv MMMMPPPPIIII____CCCCOOOORRRREEEEDDDDUUUUMMMMPPPP____DDDDEEEEBBBBUUUUGGGGGGGGEEEERRRR ////mmmmyyyy////tttteeeesssstttt////vvvveeeerrrrssssiiiioooonnnn////ooooffff////iiiiddddbbbb
  688.           sssseeeetttteeeennnnvvvv MMMMPPPPIIII____CCCCOOOORRRREEEEDDDDUUUUMMMMPPPP____DDDDEEEEBBBBUUUUGGGGGGGGEEEERRRR """"((((eeeecccchhhhoooo pppprrrriiiinnnntttt mmmmyyyy____ffffaaaavvvvoooorrrriiiitttteeee____vvvvaaaarrrriiiiaaaabbbblllleeee;;;; eeeecccchhhhoooo wwwwhhhheeeerrrreeee;;;; eeeecccchhhhoooo qqqquuuuiiiitttt)))) |||| ggggddddbbbb ----pppp %%%%dddd""""
  689.           sssseeeetttteeeennnnvvvv MMMMPPPPIIII____CCCCOOOORRRREEEEDDDDUUUUMMMMPPPP____DDDDEEEEBBBBUUUUGGGGGGGGEEEERRRR ''''((((eeeecccchhhhoooo sssseeeetttt \\\\$$$$ssssttttooooppppoooonnnnaaaattttttttaaaacccchhhh ==== 1111;;;; eeeecccchhhhoooo aaaattttttttaaaacccchhhh %%%%dddd ////pppprrrroooocccc////%%%%dddd////eeeexxxxeeee;;;; eeeecccchhhhoooo wwwwhhhheeeerrrreeee;;;; eeeecccchhhhoooo qqqquuuuiiiitttt)))) |||| ////sssswwww////ccccoooommmm////iiiinnnntttteeeellll----ccccoooommmmppppiiiilllleeeerrrrssss////7777....1111....000011113333////ccccoooommmmppppiiiilllleeeerrrr77770000////iiiiaaaa66664444////bbbbiiiinnnn////iiiiddddbbbb |||| sssseeeedddd ----eeee """"ssss////^^^^////ccccoooorrrreeeedddduuuummmmpppp:::: ////""""''''
  690.  
  691.  
  692.           Default: iiiiddddbbbb
  693.  
  694.      MMMMPPPPIIII____CCCCOOOORRRREEEEDDDDUUUUMMMMPPPP____VVVVEEEERRRRBBBBOOOOSSSSEEEE
  695.           Instructs mmmmppppiiiirrrruuuunnnn(1) to print information about coredump control and
  696.           traceback handling.   Notably, a message will be printed if a user-
  697.           or library-registered signal handler overrides a signal handler
  698.           which the MPT library would otherwise have installed.  Output is
  699.           sent to ssssttttddddeeeerrrrrrrr.
  700.  
  701.           Default: Not enabled
  702.  
  703.      MMMMPPPPIIII____DDDDIIIIRRRR
  704.           Sets the working directory on a host. When an mmmmppppiiiirrrruuuunnnn(1) command is
  705.           issued, the Array Services daemon on the local or distributed node
  706.           responds by creating a user session and starting the required MPI
  707.           processes. The user ID for the session is that of the user who
  708.           invokes mmmmppppiiiirrrruuuunnnn, so this user must be listed in the ....rrrrhhhhoooossssttttssss file on
  709.           the corresponding nodes. By default, the working directory for the
  710.           session is the user's $$$$HHHHOOOOMMMMEEEE directory on each node. You can direct
  711.           all nodes to a different directory (an NFS directory that is
  712.           available to all nodes, for example) by setting the MMMMPPPPIIII____DDDDIIIIRRRR variable
  713.           to a different directory.
  714.  
  715.           Default:  $$$$HHHHOOOOMMMMEEEE on the node. If using the ----nnnnpppp option of mmmmppppiiiirrrruuuunnnn(1),
  716.           the default is the current directory.
  717.  
  718.  
  719.  
  720.  
  721.  
  722.  
  723.                                                                        PPPPaaaaggggeeee 11111111
  724.  
  725.  
  726.  
  727.  
  728.  
  729.  
  730. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  731.  
  732.  
  733.  
  734.      MMMMPPPPIIII____DDDDPPPPLLLLAAAACCCCEEEE____IIIINNNNTTTTEEEERRRROOOOPPPP____OOOOFFFFFFFF (IRIX systems only)
  735.           Disables an MPI/dplace interoperability feature available beginning
  736.           with IRIX 6.5.13.  By setting this variable, you can obtain the
  737.           behavior of MPI with dplace on older releases of IRIX.
  738.  
  739.           Default:  Not enabled
  740.  
  741.      MMMMPPPPIIII____DDDDSSSSMMMM____CCCCPPPPUUUULLLLIIIISSSSTTTT
  742.           Specifies a list of CPUs on which to run an MPI application.  To
  743.           ensure that processes are linked to CPUs, this variable should be
  744.           used in conjunction with the MMMMPPPPIIII____DDDDSSSSMMMM____MMMMUUUUSSSSTTTTRRRRUUUUNNNN variable.
  745.  
  746.           For an explanation of the syntax for this environment variable, see
  747.           the section titled "Using a CPU List."
  748.  
  749.      MMMMPPPPIIII____DDDDSSSSMMMM____CCCCPPPPUUUULLLLIIIISSSSTTTT____TTTTYYYYPPPPEEEE
  750.           Specifies the way in which MPI should interpret the CPU values given
  751.           by the MMMMPPPPIIII____DDDDSSSSMMMM____CCCCPPPPUUUULLLLIIIISSSSTTTT variable.  This variable can be set to the
  752.           following values:
  753.  
  754.                VVVVaaaalllluuuueeee          AAAAccccttttiiiioooonnnn
  755.  
  756.                hhhhwwwwggggrrrraaaapppphhhh        This tells MPI to interpret the CPU numbers
  757.                               designated by the MMMMPPPPIIII____DDDDSSSSMMMM____CCCCPPPPUUUULLLLIIIISSSSTTTT variable as
  758.                               ccccppppuuuunnnnuuuummmm values as defined in the hardware
  759.                               graph(see hhhhwwwwggggrrrraaaapppphhhh(4)). This is the default
  760.                               interpretation when running MPI outside of a
  761.                               cpuset(see ccccppppuuuusssseeeetttt(4)).
  762.  
  763.                ccccppppuuuusssseeeetttt         This tells MPI to interpret the CPU numbers
  764.                               designated by the MMMMPPPPIIII____DDDDSSSSMMMM____CCCCPPPPUUUULLLLIIIISSSSTTTT variable as
  765.                               relative processors within a cpuset.  This is
  766.                               the default interpretation of this list when MPI
  767.                               is running within a cpuset.  Setting
  768.                               MMMMPPPPIIII____DDDDSSSSMMMM____CCCCPPPPUUUULLLLIIIISSSSTTTT____TTTTYYYYPPPPEEEE to this value when not
  769.                               running within a cpuset has no effect.
  770.  
  771.      MMMMPPPPIIII____DDDDSSSSMMMM____DDDDIIIISSSSTTTTRRRRIIIIBBBBUUUUTTTTEEEE (Linux systems only)
  772.           Ensures that each MPI process gets a unique CPU and physical memory
  773.           on the node with which that CPU is associated.  Currently, the CPUs
  774.           are chosen by simply starting at relative CPU 0 and incrementing
  775.           until all MPI processes have been forked.  To choose specific CPUs,
  776.           use the MMMMPPPPIIII____DDDDSSSSMMMM____CCCCPPPPUUUULLLLIIIISSSSTTTT environment variable.  This feature is most
  777.           useful if running on a dedicated system or running within a cpuset.
  778.  
  779.           Default:  Not enabled
  780.  
  781.      MMMMPPPPIIII____DDDDSSSSMMMM____MMMMUUUUSSSSTTTTRRRRUUUUNNNN
  782.           Enforces memory locality for MPI processes.  Use of this feature
  783.           ensures that each MPI process will get a CPU and physical memory on
  784.           the node to which it was originally assigned.  This variable has
  785.           been observed to improve program performance on IRIX systems running
  786.  
  787.  
  788.  
  789.                                                                        PPPPaaaaggggeeee 11112222
  790.  
  791.  
  792.  
  793.  
  794.  
  795.  
  796. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  797.  
  798.  
  799.  
  800.           release 6.5.7 and earlier, when running a program on a quiet system.
  801.           With later IRIX releases, under certain circumstances, setting this
  802.           variable is not necessary. Internally, this feature directs the
  803.           library to use the pppprrrroooocccceeeessssssss____ccccppppuuuulllliiiinnnnkkkk(3) function instead of
  804.           pppprrrroooocccceeeessssssss____mmmmllllddddlllliiiinnnnkkkk(3) to control memory placement.
  805.  
  806.           MMMMPPPPIIII____DDDDSSSSMMMM____MMMMUUUUSSSSTTTTRRRRUUUUNNNN should not be used when the job is submitted to
  807.           miser (see mmmmiiiisssseeeerrrr____ssssuuuubbbbmmmmiiiitttt(1)) because program hangs may result.
  808.  
  809.           The pppprrrroooocccceeeessssssss____ccccppppuuuulllliiiinnnnkkkk(3) function is inherited across process ffffoooorrrrkkkk(2)
  810.           or sssspppprrrroooocccc(2).  For this reason, when using mixed MPI/OpenMP
  811.           applications, it is recommended either that this variable not be
  812.           set, or that ____DDDDSSSSMMMM____MMMMUUUUSSSSTTTTRRRRUUUUNNNN also be set (see ppppeeee____eeeennnnvvvviiiirrrroooonnnn(5)).
  813.  
  814.           On Linux systems, this environment variable has been deprecated and
  815.           will be removed in a future release. Use the MMMMPPPPIIII____DDDDSSSSMMMM____DDDDIIIISSSSTTTTRRRRIIIIBBBBUUUUTTTTEEEE
  816.           environment variable instead.
  817.  
  818.           Default:  Not enabled
  819.  
  820.      MMMMPPPPIIII____DDDDSSSSMMMM____OOOOFFFFFFFF
  821.           Turns off nonuniform memory access (NUMA) optimization in the MPI
  822.           library.
  823.  
  824.           Default:  Not enabled
  825.  
  826.      MMMMPPPPIIII____DDDDSSSSMMMM____PPPPLLLLAAAACCCCEEEEMMMMEEEENNNNTTTT (IRIX systems only)
  827.           Specifies the default placement policy to be used for the stack and
  828.           data segments of an MPI process.  Set this variable to one of the
  829.           following values:
  830.  
  831.                VVVVaaaalllluuuueeee          AAAAccccttttiiiioooonnnn
  832.  
  833.                ffffiiiirrrrssssttttttttoooouuuucccchhhh     With this policy, IRIX attempts to satisfy
  834.                               requests for new memory pages for stack, data,
  835.                               and heap memory on the node where the requesting
  836.                               process is currently scheduled.
  837.  
  838.                ffffiiiixxxxeeeedddd          With this policy, IRIX attempts to satisfy
  839.                               requests for new memory pages for stack, data,
  840.                               and heap memory on the node associated with the
  841.                               memory locality domain (mld) with which an MPI
  842.                               process was linked at job startup. This is the
  843.                               default policy for MPI processes.
  844.  
  845.                rrrroooouuuunnnnddddrrrroooobbbbiiiinnnn     With this policy, IRIX attempts to satisfy
  846.                               requests for new memory pages in a round robin
  847.                               fashion across all of the nodes associated with
  848.                               the MPI job. It is generally not recommended to
  849.                               use this setting.
  850.  
  851.  
  852.  
  853.  
  854.  
  855.                                                                        PPPPaaaaggggeeee 11113333
  856.  
  857.  
  858.  
  859.  
  860.  
  861.  
  862. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  863.  
  864.  
  865.  
  866.                tttthhhhrrrreeeeaaaaddddrrrroooouuuunnnnddddrrrroooobbbbiiiinnnn
  867.                               This policy is intended for use with hybrid
  868.                               MPI/OpenMP applications only. With this policy,
  869.                               IRIX attempts to satisfy requests for new memory
  870.                               pages for the MPI process stack, data, and heap
  871.                               memory in a roundrobin fashion across the nodes
  872.                               allocated to its OpenMP threads. This placement
  873.                               option might be helpful for large OpenMP/MPI
  874.                               process ratios.  For non-OpenMP applications,
  875.                               this value is ignored.
  876.  
  877.           Default:  ffffiiiixxxxeeeedddd
  878.  
  879.      MMMMPPPPIIII____DDDDSSSSMMMM____PPPPPPPPMMMM
  880.           Sets the number of MPI processes per memory locality domain (mld).
  881.           For Origin 2000 systems, values of 1 or 2 are allowed. For Origin
  882.           3000 and Origin 300 systems, values of 1, 2, or 4 are allowed. On
  883.           Altix systems, values of 1 or 2 are allowed.
  884.  
  885.           Default:  Origin 2000 systems, 2; Origin 3000 and Origin 300
  886.           systems, 4; Altix systems, 2.
  887.  
  888.      MMMMPPPPIIII____DDDDSSSSMMMM____TTTTOOOOPPPPOOOOLLLLOOOOGGGGYYYY (IRIX systems only)
  889.           Specifies the shape of the set of hardware nodes on which the PE
  890.           memories are allocated.  Set this variable to one of the following
  891.           values:
  892.  
  893.                VVVVaaaalllluuuueeee          AAAAccccttttiiiioooonnnn
  894.  
  895.                ccccuuuubbbbeeee           A group of memory nodes that form a perfect
  896.                               hypercube.  The number of processes per host
  897.                               must be a power of 2.  If a perfect hypercube is
  898.                               unavailable, a less restrictive placement will
  899.                               be used.
  900.  
  901.                ccccuuuubbbbeeee____ffffiiiixxxxeeeedddd     A group of memory nodes that form a perfect
  902.                               hypercube.  The number of processes per host
  903.                               must be a power of 2.  If a perfect hypercube is
  904.                               unavailable, the placement will fail, disabling
  905.                               NUMA placement.
  906.  
  907.                ccccppppuuuucccclllluuuusssstttteeeerrrr     Any group of memory nodes.  The operating system
  908.                               attempts to place the group numbers close to one
  909.                               another, taking into account nodes with disabled
  910.                               processors.  (Default for Irix 6.5.11 and
  911.                               higher).
  912.  
  913.                ffffrrrreeeeeeee           Any group of memory nodes.  The operating system
  914.                               attempts to place the group numbers close to one
  915.                               another.  (Default for Irix 6.5.10 and earler
  916.                               releases).
  917.  
  918.  
  919.  
  920.  
  921.                                                                        PPPPaaaaggggeeee 11114444
  922.  
  923.  
  924.  
  925.  
  926.  
  927.  
  928. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  929.  
  930.  
  931.  
  932.      MMMMPPPPIIII____DDDDSSSSMMMM____VVVVEEEERRRRBBBBOOOOSSSSEEEE
  933.           Instructs mmmmppppiiiirrrruuuunnnn(1) to print information about process placement for
  934.           jobs running on nonuniform memory access (NUMA) machines (unless
  935.           MMMMPPPPIIII____DDDDSSSSMMMM____OOOOFFFFFFFF is also set). Output is sent to ssssttttddddeeeerrrrrrrr.
  936.  
  937.           Default:  Not enabled
  938.  
  939.      MMMMPPPPIIII____DDDDSSSSMMMM____VVVVEEEERRRRIIIIFFFFYYYY (IRIX systems only)
  940.           Instructs mmmmppppiiiirrrruuuunnnn(1) to run some diagnostic checks on proper memory
  941.           placement of MPI data structures at job startup. If errors are
  942.           found, a diagnostic message is printed to ssssttttddddeeeerrrrrrrr.
  943.  
  944.           Default:  Not enabled
  945.  
  946.      MMMMPPPPIIII____GGGGMMMM____DDDDEEEEVVVVSSSS (IRIX systems only)
  947.           Sets the order for opening GM(Myrinet) adapters. The list of devices
  948.           does not need to be space-delimited (0321 is valid).  The syntax is
  949.           the same as for the MMMMPPPPIIII____BBBBYYYYPPPPAAAASSSSSSSS____DDDDEEEEVVVVSSSS environment variable.  In this
  950.           release, a maximum of 8 adpaters are supported on a single host.
  951.  
  952.           Default:  MPI will use all available GM(Myrinet) devices.
  953.  
  954.      MMMMPPPPIIII____GGGGMMMM____VVVVEEEERRRRBBBBOOOOSSSSEEEE
  955.           Setting this variable allows some diagnostic information concerning
  956.           messaging between processes using GM (Myrinet) to be displayed on
  957.           stderr.
  958.  
  959.           Default:  Not enabled
  960.  
  961.      MMMMPPPPIIII____GGGGRRRROOOOUUUUPPPP____MMMMAAAAXXXX
  962.           Determines the maximum number of groups that can simultaneously
  963.           exist for any single MPI process.  Use this variable to increase
  964.           internal default limits. (This variable might be required by
  965.           standard-compliant programs.)  MPI generates an error message if
  966.           this limit (or the default, if not set) is exceeded.
  967.  
  968.           Default:  32
  969.  
  970.      MMMMPPPPIIII____GGGGSSSSNNNN____DDDDEEEEVVVVSSSS (IRIX 6.5.12 systems or later)
  971.           Sets the order for opening GSN adapters. The list of devices does
  972.           not need to be quoted or space-delimited (0123 is valid).
  973.  
  974.           Default:  MPI will use all available GSN devices
  975.  
  976.      MMMMPPPPIIII____GGGGSSSSNNNN____VVVVEEEERRRRBBBBOOOOSSSSEEEE (IRIX 6.5.12 systems or later)
  977.           Allows additional MPI initialization information to be printed in
  978.           the standard output stream. This information contains details about
  979.           the GSN (ST protocol) OS bypass connections and the GSN adapters
  980.           that are detected on each of the hosts.
  981.  
  982.           Default:  Not enabled
  983.  
  984.  
  985.  
  986.  
  987.                                                                        PPPPaaaaggggeeee 11115555
  988.  
  989.  
  990.  
  991.  
  992.  
  993.  
  994. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  995.  
  996.  
  997.  
  998.      MMMMPPPPIIII____MMMMAAAAPPPPPPPPEEEEDDDD____HHHHEEEEAAAAPPPP____SSSSIIIIZZZZEEEE (Linux systems only)
  999.           Sets the new size (in bytes) for the amount of heap that is memory
  1000.           mapped per MPI process.  The default size of the mapped heap is the
  1001.           physical memory available per CPU less the static region size. For
  1002.           more information regarding memory mapping, see MMMMPPPPIIII____MMMMEEEEMMMMMMMMAAAAPPPP____OOOOFFFFFFFF.
  1003.  
  1004.           Default:  The physical memory available per CPU less the static
  1005.           region size
  1006.  
  1007.      MMMMPPPPIIII____MMMMAAAAPPPPPPPPEEEEDDDD____SSSSTTTTAAAACCCCKKKK____SSSSIIIIZZZZEEEE (Linux systems only)
  1008.           Sets the new size (in bytes) for the amount of stack that is memory
  1009.           mapped per MPI process.  The default size of the mapped stack is the
  1010.           stack limit size. If the stack is unlimited, the mapped region is
  1011.           set to the physical memory available per CPU. For more information
  1012.           regarding memory mapping, see MMMMPPPPIIII____MMMMEEEEMMMMMMMMAAAAPPPP____OOOOFFFFFFFF.
  1013.  
  1014.           Default:  The stack limit size
  1015.  
  1016.      MMMMPPPPIIII____MMMMEEEEMMMMMMMMAAAAPPPP____OOOOFFFFFFFF (Linux systems only)
  1017.           Turns off the memory mapping feature.
  1018.  
  1019.           The memory mapping feature provides support for single-copy
  1020.           transfers and MPI-2 one-sided communication on Linux.  These
  1021.           features are supported for single host MPI jobs and MPI jobs that
  1022.           span partitions. At job startup, MPI uses the xpmem module to map
  1023.           memory from one MPI process onto another.  The mapped areas include
  1024.           the static region, private heap, and stack.
  1025.  
  1026.           Memory mapping is enabled by default on Linux.  To disable it, set
  1027.           the MMMMPPPPIIII____MMMMEEEEMMMMMMMMAAAAPPPP____OOOOFFFFFFFF environment variable.
  1028.  
  1029.           For memory mapping, the xpmem kernel module must be installed on
  1030.           your system.  The xpmem module is released with the OS.
  1031.  
  1032.           Default: Not enabled
  1033.  
  1034.      MMMMPPPPIIII____MMMMEEEEMMMMMMMMAAAAPPPP____VVVVEEEERRRRBBBBOOOOSSSSEEEE (Linux systems only)
  1035.           Allows MPI to display additional information regarding the memory
  1036.           mapping initialization sequence.  Output is sent to ssssttttddddeeeerrrrrrrr.
  1037.  
  1038.           Default: Not enabled
  1039.  
  1040.      MMMMPPPPIIII____MMMMSSSSGGGG____RRRREEEETTTTRRRRIIIIEEEESSSS
  1041.           Specifies the number of times the MPI library will try to get a
  1042.           message header, if none are available.  Each MPI message that is
  1043.           sent requires an initial message header.  If one is not available
  1044.           after MMMMPPPPIIII____MMMMSSSSGGGG____RRRREEEETTTTRRRRIIIIEEEESSSS, the job will abort.
  1045.  
  1046.           Note that this variable no longer applies to processes on the same
  1047.           host, or when using the GM (Myrinet) protocol. In these cases,
  1048.           message headers are allocated dynamically on an as-needed basis.
  1049.  
  1050.  
  1051.  
  1052.  
  1053.                                                                        PPPPaaaaggggeeee 11116666
  1054.  
  1055.  
  1056.  
  1057.  
  1058.  
  1059.  
  1060. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  1061.  
  1062.  
  1063.  
  1064.           Default:  500
  1065.  
  1066.      MMMMPPPPIIII____MMMMSSSSGGGGSSSS____MMMMAAAAXXXX
  1067.           This variable can be set to control the total number of message
  1068.           headers that can be allocated.  This allocation applies to messages
  1069.           exchanged between processes on a single host, or between processes
  1070.           on different hosts when using the GM(Myrinet) OS bypass protocol.
  1071.           Note that the initial allocation of memory for message headers is
  1072.           128 Kbytes.
  1073.  
  1074.           Default:  Allow up to 64 Mbytes to be allocated for message headers.
  1075.           If you set this variable, specify the maximum number of message
  1076.           headers.
  1077.  
  1078.      MMMMPPPPIIII____MMMMSSSSGGGGSSSS____PPPPEEEERRRR____HHHHOOOOSSSSTTTT
  1079.           Sets the number of message headers to allocate for MPI messages on
  1080.           each MPI host. Space for messages that are destined for a process on
  1081.           a different host is allocated as shared memory on the host on which
  1082.           the sending processes are located. MPI locks these pages in memory.
  1083.           Use the MMMMPPPPIIII____MMMMSSSSGGGGSSSS____PPPPEEEERRRR____HHHHOOOOSSSSTTTT variable to allocate buffer space for
  1084.           interhost messages.
  1085.  
  1086.           Caution:  If you set the memory pool for interhost packets to a
  1087.           large value, you can cause allocation of so much locked memory that
  1088.           total system performance is degraded.
  1089.  
  1090.           The previous description does not apply to processes that use the
  1091.           GM(Myrinet) OS bypass protocol. In this case, message headers are
  1092.           allocated dynamically as needed. See the MMMMPPPPIIII____MMMMSSSSGGGGSSSS____MMMMAAAAXXXX variable
  1093.           description.
  1094.  
  1095.           Default:  1024 messages
  1096.  
  1097.      MMMMPPPPIIII____MMMMSSSSGGGGSSSS____PPPPEEEERRRR____PPPPRRRROOOOCCCC
  1098.           This variable is effectively obsolete. Message headers are now
  1099.           allocated on an as needed basis for messaging either between
  1100.           processes on the same host, or between processes on different hosts
  1101.           when using the GM (Myrinet) OS bypass protocol.  The new
  1102.           MMMMPPPPIIII____MMMMSSSSGGGGSSSS____MMMMAAAAXXXX variable can be used to control the total number of
  1103.           message headers that can be allocated.
  1104.  
  1105.           Default:  1024
  1106.  
  1107.      MMMMPPPPIIII____NNNNAAAAPPPP
  1108.           This variable affects the way in which ranks wait for events to
  1109.           occur. For example, when a receive is issued for which there are as
  1110.           yet no matching sends, the receiving rank awaits the mmmmaaaattttcccchhhhiiiinnnngggg sssseeeennnndddd
  1111.           iiiissssssssuuuueeeedddd event.
  1112.  
  1113.           When MMMMPPPPIIII____NNNNAAAAPPPP is not defined (that is, uuuunnnnsssseeeetttteeeennnnvvvv MMMMPPPPIIII____NNNNAAAAPPPP), the library
  1114.           spins in a tight loop when awaiting events. While this provides the
  1115.           best possible response time when the event occurs, each waiting rank
  1116.  
  1117.  
  1118.  
  1119.                                                                        PPPPaaaaggggeeee 11117777
  1120.  
  1121.  
  1122.  
  1123.  
  1124.  
  1125.  
  1126. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  1127.  
  1128.  
  1129.  
  1130.           uses CPU time at wall-clock rates until then.  Leaving MMMMPPPPIIII____NNNNAAAAPPPP
  1131.           undefined is best if sends and matching receives occur nearly
  1132.           simultaneously.
  1133.  
  1134.           If defined with no value (that is, sssseeeetttteeeennnnvvvv MMMMPPPPIIII____NNNNAAAAPPPP), the library
  1135.           makes a system call while waiting, which might yield the CPU to
  1136.           another eligible process that can use it.  If no such process
  1137.           exists, the rank receives control back nearly immediately, and CPU
  1138.           time accrues at near wall-clock rates.  If another process does
  1139.           exist, it is given some CPU time, after which the MPI rank is again
  1140.           given the CPU to test for the event.  This is best if the system is
  1141.           oversubscribed (there are more processes ready to run than there are
  1142.           CPUs).  This option was previously available in MPT, but was not
  1143.           documented.
  1144.  
  1145.           If defined with a positive integer value (for example, sssseeeetttteeeennnnvvvv
  1146.           MMMMPPPPIIII____NNNNAAAAPPPP 11110000), the rank sleeps for that many milliseconds before again
  1147.           testing to determine if an event has occurred.  This dramatically
  1148.           reduces the CPU time that is charged against the rank, and might
  1149.           increase the system's "idle" time.  This setting is best if there is
  1150.           usually a significant time difference between the times that sends
  1151.           and matching receives are posted.
  1152.  
  1153.           Default:  Not applicable - one of the cases above always applies.
  1154.  
  1155.      MMMMPPPPIIII____OOOOPPPPEEEENNNNMMMMPPPP____IIIINNNNTTTTEEEERRRROOOOPPPP
  1156.           Setting this variable modifies the placement of MPI processes to
  1157.           better accomodate the OpenMP threads associated with each process.
  1158.           For more information, see the section titled UUUUssssiiiinnnngggg MMMMPPPPIIII wwwwiiiitttthhhh OOOOppppeeeennnnMMMMPPPP.
  1159.  
  1160.           NOTE: This option is available only on Origin 300 and Origin 3000
  1161.           servers and Altix systems.
  1162.  
  1163.           Default:  Not enabled
  1164.  
  1165.      MMMMPPPPIIII____RRRREEEEQQQQUUUUEEEESSSSTTTT____MMMMAAAAXXXX
  1166.           Determines the maximum number of nonblocking sends and receives that
  1167.           can simultaneously exist for any single MPI process.  Use this
  1168.           variable to increase internal default limits.  (This variable might
  1169.           be required by standard-compliant programs.)  MPI generates an error
  1170.           message if this limit (or the default, if not set) is exceeded.
  1171.  
  1172.           Default:  16384
  1173.  
  1174.      MMMMPPPPIIII____SSSSHHHHAAAARRRREEEEDDDD____VVVVEEEERRRRBBBBOOOOSSSSEEEE
  1175.           Setting this variable allows for some diagnostic information
  1176.           concerning messaging within a host to be displayed on stderr.
  1177.  
  1178.           Default:  Not enabled
  1179.  
  1180.  
  1181.  
  1182.  
  1183.  
  1184.  
  1185.                                                                        PPPPaaaaggggeeee 11118888
  1186.  
  1187.  
  1188.  
  1189.  
  1190.  
  1191.  
  1192. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  1193.  
  1194.  
  1195.  
  1196.      MMMMPPPPIIII____SSSSLLLLAAAAVVVVEEEE____DDDDEEEEBBBBUUUUGGGG____AAAATTTTTTTTAAAACCCCHHHH
  1197.           Specifies the MPI process to be debugged. If you set
  1198.           MMMMPPPPIIII____SSSSLLLLAAAAVVVVEEEE____DDDDEEEEBBBBUUUUGGGG____AAAATTTTTTTTAAAACCCCHHHH to NNNN, the MPI process with rank NNNN prints a
  1199.           message during program startup, describing how to attach to it from
  1200.           another window using the dbx debugger on IRIX or the gdb or idb
  1201.           debugger on Linux.  The message includes the number of seconds you
  1202.           have to attach the debugger to process NNNN.  If you fail to attach
  1203.           before the time expires, the process continues.
  1204.  
  1205.      MMMMPPPPIIII____SSSSTTTTAAAATTTTIIIICCCC____NNNNOOOO____MMMMAAAAPPPP (IRIX systems only)
  1206.           Disables cross mapping of static memory between MPI processes.  This
  1207.           variable can be set to reduce the significant MPI job startup and
  1208.           shutdown time that can be observed for jobs involving more than 512
  1209.           processors on a single IRIX host.  Note that setting this shell
  1210.           variable disables certain internal MPI optimizations and also
  1211.           restricts the usage of MPI-2 one-sided functions.  For more
  1212.           information, see the MMMMPPPPIIII____WWWWiiiinnnn man page.
  1213.  
  1214.           Default:  Not enabled
  1215.  
  1216.      MMMMPPPPIIII____SSSSTTTTAAAATTTTSSSS
  1217.           Enables printing of MPI internal statistics.  Each MPI process
  1218.           prints statistics about the amount of data sent with MPI calls
  1219.           during the MMMMPPPPIIII____FFFFiiiinnnnaaaalllliiiizzzzeeee process.  Data is sent to ssssttttddddeeeerrrrrrrr.  To prefix
  1220.           the statistics messages with the MPI rank, use the ----pppp option on the
  1221.           mmmmppppiiiirrrruuuunnnn command. For additional information, see the MMMMPPPPIIII____SSSSGGGGIIII____ssssttttaaaattttssss
  1222.           man page.
  1223.  
  1224.           NOTE: Because the statistics-collection code is not thread-safe,
  1225.           this variable should not be set if the program uses threads.
  1226.  
  1227.           Default:  Not enabled
  1228.  
  1229.      MMMMPPPPIIII____TTTTYYYYPPPPEEEE____DDDDEEEEPPPPTTTTHHHH
  1230.           Sets the maximum number of nesting levels for derived data types.
  1231.           (Might be required by standard-compliant programs.) The
  1232.           MMMMPPPPIIII____TTTTYYYYPPPPEEEE____DDDDEEEEPPPPTTTTHHHH variable limits the maximum depth of derived data
  1233.           types that an application can create.  MPI generates an error
  1234.           message if this limit (or the default, if not set) is exceeded.
  1235.  
  1236.           Default:  8 levels
  1237.  
  1238.      MMMMPPPPIIII____TTTTYYYYPPPPEEEE____MMMMAAAAXXXX
  1239.           Determines the maximum number of data types that can simultaneously
  1240.           exist for any single MPI process. Use this variable to increase
  1241.           internal default limits.  (This variable might be required by
  1242.           standard-compliant programs.)  MPI generates an error message if
  1243.           this limit (or the default, if not set) is exceeded.
  1244.  
  1245.           Default:  1024
  1246.  
  1247.  
  1248.  
  1249.  
  1250.  
  1251.                                                                        PPPPaaaaggggeeee 11119999
  1252.  
  1253.  
  1254.  
  1255.  
  1256.  
  1257.  
  1258. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  1259.  
  1260.  
  1261.  
  1262.      MMMMPPPPIIII____UUUUNNNNBBBBUUUUFFFFFFFFEEEERRRREEEEDDDD____SSSSTTTTDDDDIIIIOOOO
  1263.           Normally, mmmmppppiiiirrrruuuunnnn line-buffers output received from the MPI processes
  1264.           on both the ssssttttddddoooouuuutttt and ssssttttddddeeeerrrrrrrr standard IO streams.  This prevents
  1265.           lines of text from different processes from possibly being merged
  1266.           into one line, and allows use of the mmmmppppiiiirrrruuuunnnn ----pppprrrreeeeffffiiiixxxx option.
  1267.  
  1268.           Of course, there is a limit to the amount of buffer space that
  1269.           mmmmppppiiiirrrruuuunnnn has available (currently, about 8,100 characters can appear
  1270.           between new line characters per stream per process).  If more
  1271.           characters are emitted before a new line character, the MPI program
  1272.           will abort with an error message.
  1273.  
  1274.           Setting the MMMMPPPPIIII____UUUUNNNNBBBBUUUUFFFFFFFFEEEERRRREEEEDDDD____SSSSTTTTDDDDIIIIOOOO environment variable disables this
  1275.           buffering.  This is useful, for example, when a program's rank 0
  1276.           emits a series of periods over time to indicate progress of the
  1277.           program. With buffering, the entire line of periods will be output
  1278.           only when the new line character is seen.  Without buffering, each
  1279.           period will be immediately displayed as soon as mmmmppppiiiirrrruuuunnnn receives it
  1280.           from the MPI program.   (Note that the MPI program still needs to
  1281.           call fffffffflllluuuusssshhhh(3) or FFFFLLLLUUUUSSSSHHHH((((111100001111)))) to flush the ssssttttddddoooouuuutttt buffer from the
  1282.           application code.)
  1283.  
  1284.           Additionally, setting MMMMPPPPIIII____UUUUNNNNBBBBUUUUFFFFFFFFEEEERRRREEEEDDDD____SSSSTTTTDDDDIIIIOOOO allows an MPI program
  1285.           that emits very long output lines to execute correctly.
  1286.  
  1287.           NOTE: If MMMMPPPPIIII____UUUUNNNNBBBBUUUUFFFFFFFFEEEERRRREEEEDDDD____SSSSTTTTDDDDIIIIOOOO is set, the mmmmppppiiiirrrruuuunnnn ----pppprrrreeeeffffiiiixxxx option is
  1288.           ignored.
  1289.  
  1290.           Default:  Not set
  1291.  
  1292.      MMMMPPPPIIII____UUUUSSSSEEEE____GGGGMMMM  (IRIX systems only)
  1293.           Requires the MPI library to use the Myrinet (GM protocol) OS bypass
  1294.           driver as the interconnect when running across multiple hosts or
  1295.           running with multiple binaries.  If a GM connection cannot be
  1296.           established among all hosts in the MPI job, the job is terminated.
  1297.  
  1298.           For more information, see the section titled "Default Interconnect
  1299.           Selection."
  1300.  
  1301.           Default:  Not set
  1302.  
  1303.      MMMMPPPPIIII____UUUUSSSSEEEE____GGGGSSSSNNNN (IRIX 6.5.12 systems or later)
  1304.           Requires the MPI library to use the GSN (ST protocol) OS bypass
  1305.           driver as the interconnect when running across multiple hosts or
  1306.           running with multiple binaries.  If a GSN connection cannot be
  1307.           established among all hosts in the MPI job, the job is terminated.
  1308.  
  1309.           GSN imposes a limit of one MPI process using GSN per CPU on a
  1310.           system. For example, on a 128-CPU system, you can run multiple MPI
  1311.           jobs, as long as the total number of MPI processes using the GSN
  1312.           bypass does not exceed 128.
  1313.  
  1314.  
  1315.  
  1316.  
  1317.                                                                        PPPPaaaaggggeeee 22220000
  1318.  
  1319.  
  1320.  
  1321.  
  1322.  
  1323.  
  1324. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  1325.  
  1326.  
  1327.  
  1328.           Once the maximum allowed MPI processes using GSN is reached,
  1329.           subsequent MPI jobs return an error to the user output, as in the
  1330.           following example:
  1331.  
  1332.                  MMMMPPPPIIII:::: CCCCoooouuuulllldddd nnnnooootttt ccccoooonnnnnnnneeeecccctttt aaaallllllll pppprrrroooocccceeeesssssssseeeessss ttttoooo GGGGSSSSNNNN aaaaddddaaaapppptttteeeerrrrssss.... TTTThhhheeee mmmmaaaaxxxxiiiimmmmuuuummmm
  1333.                       nnnnuuuummmmbbbbeeeerrrr ooooffff GGGGSSSSNNNN aaaaddddaaaapppptttteeeerrrr ccccoooonnnnnnnneeeeccccttttiiiioooonnnnssss ppppeeeerrrr ssssyyyysssstttteeeemmmm iiiissss nnnnoooorrrrmmmmaaaallllllllyyyy eeeeqqqquuuuaaaallll
  1334.                       ttttoooo tttthhhheeee nnnnuuuummmmbbbbeeeerrrr ooooffff CCCCPPPPUUUUssss oooonnnn tttthhhheeee ssssyyyysssstttteeeemmmm....
  1335.  
  1336.  
  1337.           If there are a few CPUs still available, but not enough to satisfy
  1338.           the entire MPI job, the error will still be issued and the MPI job
  1339.           terminated.
  1340.  
  1341.           For more information, see the section titled "Default Interconnect
  1342.           Selection."
  1343.  
  1344.           Default:  Not set
  1345.  
  1346.      MMMMPPPPIIII____UUUUSSSSEEEE____HHHHIIIIPPPPPPPPIIII  (IRIX systems only)
  1347.           Requires the MPI library to use the HiPPI 800 OS bypass driver as
  1348.           the interconnect when running across multiple hosts or running with
  1349.           multiple binaries.  If a HiPPI connection cannot be established
  1350.           among all hosts in the MPI job, the job is terminated.
  1351.  
  1352.           For more information, see the section titled "Default Interconnect
  1353.           Selection."
  1354.  
  1355.           Default:  Not set
  1356.  
  1357.      MMMMPPPPIIII____UUUUSSSSEEEE____TTTTCCCCPPPP
  1358.           Requires the MPI library to use the TCP/IP driver as the
  1359.           interconnect when running across multiple hosts or running with
  1360.           multiple binaries.
  1361.  
  1362.           For more information, see the section titled "Default Interconnect
  1363.           Selection."
  1364.  
  1365.           Default:  Not set
  1366.  
  1367.      MMMMPPPPIIII____UUUUSSSSEEEE____XXXXPPPPMMMMEEEEMMMM  (IRIX 6.5.13 systems or later and Linux systems)
  1368.           Requires the MPI library to use the XPMEM driver as the interconnect
  1369.           when running across multiple hosts or running with multiple
  1370.           binaries.  This driver allows MPI processes running on one partition
  1371.           to communicate with MPI processes on a different partition via the
  1372.           NUMAlink network.  The NUMAlink network is powered by block transfer
  1373.           engines (BTEs).  BTE data transfers do not require processor
  1374.           resources.
  1375.  
  1376.           For IRIX, the XPMEM (cross partition) device driver is available
  1377.           only on Origin 3000 and Origin 300 systems running IRIX 6.5.13 or
  1378.           greater.
  1379.  
  1380.  
  1381.  
  1382.  
  1383.                                                                        PPPPaaaaggggeeee 22221111
  1384.  
  1385.  
  1386.  
  1387.  
  1388.  
  1389.  
  1390. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  1391.  
  1392.  
  1393.  
  1394.           NOTE: Due to possible MPI program hangs, you should not run MPI
  1395.           across partitions using the XPMEM driver on IRIX versions 6.5.13,
  1396.           6.5.14, or 6.5.15.  This problem has been resolved in IRIX version
  1397.           6.5.16.
  1398.  
  1399.           For Linux, the XPMEM device driver requires the xpmem kernel module
  1400.           to be installed.  The xpmem module is released with the OS.
  1401.  
  1402.           If all of the hosts specified on the mmmmppppiiiirrrruuuunnnn command do not reside in
  1403.           the same partitioned system, you can select one additional
  1404.           interconnect via the MMMMPPPPIIII____UUUUSSSSEEEE variables.  MPI communication between
  1405.           partitions will go through the XPMEM driver, and communication
  1406.           between non-partitioned hosts will go through the second
  1407.           interconnect.
  1408.  
  1409.           For more information, see the section titled "Default Interconnect
  1410.           Selection."
  1411.  
  1412.           Default:  Not set
  1413.  
  1414.      MMMMPPPPIIII____XXXXPPPPMMMMEEEEMMMM____OOOONNNN (IRIX 6.5.15 systems or later)
  1415.           Enables the XPMEM single-copy enhancements for processes residing on
  1416.           the same host.
  1417.  
  1418.           The XPMEM enhancements allow single-copy transfers for basic
  1419.           predefined MPI data types from any sender data location, including
  1420.           the stack and private heap.  Without enabling XPMEM, single-copy is
  1421.           allowed only from data residing in the symmetric data, symmetric
  1422.           heap, or global heap.
  1423.  
  1424.           Both the MMMMPPPPIIII____XXXXPPPPMMMMEEEEMMMM____OOOONNNN and MMMMPPPPIIII____BBBBUUUUFFFFFFFFEEEERRRR____MMMMAAAAXXXX variables must be set to
  1425.           enable these enhancements.  Both are disabled by default.
  1426.  
  1427.           If the following additional conditions are met, the block transfer
  1428.           engine (BTE) is invoked instead of bbbbccccooooppppyyyy, to provide increased
  1429.           bandwidth:
  1430.  
  1431.                *   Send and receive buffers are cache-aligned.
  1432.  
  1433.                *   Amount of data to transfer is greater than or equal to the
  1434.                    MMMMPPPPIIII____XXXXPPPPMMMMEEEEMMMM____TTTTHHHHRRRREEEESSSSHHHHOOOOLLLLDDDD value.
  1435.  
  1436.           NOTE:  The XPMEM driver does not support checkpoint/restart at this
  1437.           time. If you enable these XPMEM enhancements, you will not be able
  1438.           to checkpoint and restart your MPI job.
  1439.  
  1440.           The XPMEM single-copy enhancements require an Origin 3000 and Origin
  1441.           300 servers running IRIX release 6.5.15 or greater.
  1442.  
  1443.           Default: Not set
  1444.  
  1445.  
  1446.  
  1447.  
  1448.  
  1449.                                                                        PPPPaaaaggggeeee 22222222
  1450.  
  1451.  
  1452.  
  1453.  
  1454.  
  1455.  
  1456. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  1457.  
  1458.  
  1459.  
  1460.      MMMMPPPPIIII____XXXXPPPPMMMMEEEEMMMM____TTTTHHHHRRRREEEESSSSHHHHOOOOLLLLDDDD (IRIX 6.5.15 systems or later)
  1461.           Specifies a minimum message size, in bytes, for which single-copy
  1462.           messages between processes residing on the same host will be
  1463.           transferred via the BTE, instead of bbbbccccooooppppyyyy.  The following conditions
  1464.           must exist before the BTE transfer is invoked:
  1465.  
  1466.                *   Single-copy mode is enabled (MMMMPPPPIIII____BBBBUUUUFFFFFFFFEEEERRRR____MMMMAAAAXXXX).
  1467.  
  1468.                *   XPMEM single-copy enhancements are enabled (MMMMPPPPIIII____XXXXPPPPMMMMEEEEMMMM____OOOONNNN).
  1469.  
  1470.                *   Send and receive buffers are cache-aligned.
  1471.  
  1472.                *   Amount of data to transfer is greater than or equal to the
  1473.                    MMMMPPPPIIII____XXXXPPPPMMMMEEEEMMMM____TTTTHHHHRRRREEEESSSSHHHHOOOOLLLLDDDD value.
  1474.  
  1475.           Default: 8192
  1476.  
  1477.      MMMMPPPPIIII____XXXXPPPPMMMMEEEEMMMM____VVVVEEEERRRRBBBBOOOOSSSSEEEE
  1478.           Setting this variable allows additional MPI diagnostic information
  1479.           to be printed in the standard output stream. This information
  1480.           contains details about the XPMEM connections.
  1481.  
  1482.           Default:  Not enabled
  1483.  
  1484.      PPPPAAAAGGGGEEEESSSSIIIIZZZZEEEE____DDDDAAAATTTTAAAA (IRIX systems only)
  1485.           Specifies the desired page size in kilobytes for program data areas.
  1486.           On Origin series systems, supported values include 16, 64, 256,
  1487.           1024, and 4096.  Specified values must be integer.
  1488.  
  1489.           NOTE:  Setting MMMMPPPPIIII____DDDDSSSSMMMM____OOOOFFFFFFFF  disables the ability to set the data
  1490.           pagesize via this shell variable.
  1491.  
  1492.           Default:  Not enabled
  1493.  
  1494.      PPPPAAAAGGGGEEEESSSSIIIIZZZZEEEE____SSSSTTTTAAAACCCCKKKK (IRIX systems only)
  1495.           Specifies the desired page size in kilobytes for program stack
  1496.           areas.  On Origin series systems, supported values include 16, 64,
  1497.           256, 1024, and 4096.  Specified values must be integer.
  1498.  
  1499.           NOTE:  Setting MMMMPPPPIIII____DDDDSSSSMMMM____OOOOFFFFFFFF  disables the ability to set the data
  1500.           page size via this shell variable.
  1501.  
  1502.           Default:  Not enabled
  1503.  
  1504.      SSSSMMMMAAAA____GGGGLLLLOOOOBBBBAAAALLLL____AAAALLLLLLLLOOOOCCCC (IRIX systems only)
  1505.           Activates the LIBSMA based global heap facility.  This variable is
  1506.           used by 64-bit MPI applications for certain internal optimizations,
  1507.           as well as support for the MMMMPPPPIIII____AAAAlllllllloooocccc____mmmmeeeemmmm function. For additional
  1508.           details, see the iiiinnnnttttrrrroooo____sssshhhhmmmmeeeemmmm(3) man page.
  1509.  
  1510.           Default: Not enabled
  1511.  
  1512.  
  1513.  
  1514.  
  1515.                                                                        PPPPaaaaggggeeee 22223333
  1516.  
  1517.  
  1518.  
  1519.  
  1520.  
  1521.  
  1522. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  1523.  
  1524.  
  1525.  
  1526.      SSSSMMMMAAAA____GGGGLLLLOOOOBBBBAAAALLLL____HHHHEEEEAAAAPPPP____SSSSIIIIZZZZEEEE (IRIX systems only)
  1527.           For 64-bit applications, specifies the per process size of the
  1528.           LIBSMA global heap in bytes.
  1529.  
  1530.           Default: 33554432 bytes
  1531.  
  1532.    UUUUssssiiiinnnngggg aaaa CCCCPPPPUUUU LLLLiiiisssstttt
  1533.      You can manually select CPUs to use for an MPI application by setting the
  1534.      MMMMPPPPIIII____DDDDSSSSMMMM____CCCCPPPPUUUULLLLIIIISSSSTTTT shell variable.  This setting is treated as a comma
  1535.      and/or hyphen delineated ordered list, specifying a mapping of MPI
  1536.      processes to CPUs.  If running across multiple hosts, the per host
  1537.      components of the CPU list are delineated by colons.  The shepherd
  1538.      process(es) and mmmmppppiiiirrrruuuunnnn are not included in this list. This feature will
  1539.      not be compatible with job migration features available in future IRIX
  1540.      releases.
  1541.  
  1542.      Examples:
  1543.  
  1544.                VVVVaaaalllluuuueeee          CCCCPPPPUUUU AAAAssssssssiiiiggggnnnnmmmmeeeennnntttt
  1545.  
  1546.                8888,,,,11116666,,,,33332222        Place three MPI processes on CPUs 8, 16, and 32.
  1547.  
  1548.                33332222,,,,11116666,,,,8888        Place the MPI process rank zero on CPU 32, one
  1549.                               on 16, and two on CPU 8.
  1550.  
  1551.                8888----11115555,,,,33332222----33339999     Place the MPI processes 0 through 7 on CPUs 8 to
  1552.                               15.  Place the MPI processes 8 through 15 on
  1553.                               CPUs 32 to 39.
  1554.  
  1555.                33339999----33332222,,,,8888----11115555     Place the MPI processes 0 through 7 on CPUs 39
  1556.                               to 32.  Place the MPI processes 8 through 15 on
  1557.                               CPUs 8 to 15.
  1558.  
  1559.                8888----11115555::::11116666----22223333     Place the MPI processes 0 through 7 on the first
  1560.                               host on CPUs 8 through 15.  Place MPI processes
  1561.                               8 through 15 on CPUs 16 to 23 on the second
  1562.                               host.
  1563.  
  1564.      Note that the process rank is the MMMMPPPPIIII____CCCCOOOOMMMMMMMM____WWWWOOOORRRRLLLLDDDD rank.  The
  1565.      interpretation of the CPU values specified in the MMMMPPPPIIII____DDDDSSSSMMMM____CCCCPPPPUUUULLLLIIIISSSSTTTT depends
  1566.      on whether the MPI job is being run within a cpuset.  If the job is run
  1567.      outside of a cpuset, the CPUs specify ccccppppuuuunnnnuuuummmm values given in the hardware
  1568.      graph (hhhhwwwwggggrrrraaaapppphhhh(4)).  When running within a cpuset, the default behavior
  1569.      is to interpret the CPU values as relative processor numbers within the
  1570.      cpuset.  To specify ccccppppuuuunnnnuuuummmm values instead, you can use the
  1571.      MMMMPPPPIIII____DDDDSSSSMMMM____CCCCPPPPUUUULLLLIIIISSSSTTTT____TTTTYYYYPPPPEEEE shell variable.
  1572.  
  1573.      On Linux systems, the CPU values are always treated as relative processor
  1574.      numbers within the cpuset.  It is assumed that the system will always
  1575.      have a default (unnamed) cpuset consisting of the entire system of
  1576.      available processors and nodes.
  1577.  
  1578.  
  1579.  
  1580.  
  1581.                                                                        PPPPaaaaggggeeee 22224444
  1582.  
  1583.  
  1584.  
  1585.  
  1586.  
  1587.  
  1588. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  1589.  
  1590.  
  1591.  
  1592.      The number of processors specified should equal the number of MPI
  1593.      processes (excluding the shepherd process) that will be used.  The number
  1594.      of colon delineated parts of the list must equal the number of hosts used
  1595.      for the MPI job. If an error occurs in processing the CPU list, the
  1596.      default placement policy is used.  If the number of specified processors
  1597.      is smaller than the total number of MPI processes, only a subset of the
  1598.      MPI processes will be placed on the specified processors.  For example,
  1599.      if four processors are specified using the MMMMPPPPIIII____DDDDSSSSMMMM____CCCCPPPPUUUULLLLIIIISSSSTTTT variable, but
  1600.      five MPI processes are started, the last MPI process will not be attached
  1601.      to a processor.
  1602.  
  1603.      This feature should not be used with MMMMPPPPIIII jobs running in spawn capable
  1604.      mode.
  1605.  
  1606.    UUUUssssiiiinnnngggg MMMMPPPPIIII wwwwiiiitttthhhh OOOOppppeeeennnnMMMMPPPP
  1607.      Hybrid MPI/OpenMP applications might require special memory placement
  1608.      features to operate efficiently on ccNUMA Origin and Altix servers.  A
  1609.      method for realizing this memory placement is available.  The basic idea
  1610.      is to space out the MPI processes to accomodate the OpenMP threads
  1611.      associated with each MPI process.  In addition, assuming a particular
  1612.      ordering of library iiiinnnniiiitttt code (see the DDDDSSSSOOOO(5) man page), procedures are
  1613.      employed to insure that the OpenMP threads remain close to the parent MPI
  1614.      process. This type of placement has been found to improve the performance
  1615.      of some hybrid applications significantly when more than four OpenMP
  1616.      threads are used by each MPI process.
  1617.  
  1618.      To take partial advantage of this placement option, the following
  1619.      requirements must be met:
  1620.  
  1621.                *   The user must set the MMMMPPPPIIII____OOOOPPPPEEEENNNNMMMMPPPP____IIIINNNNTTTTEEEERRRROOOOPPPP shell variable
  1622.                    when running the application.
  1623.  
  1624.                *   On IRIX systems, the user must use a MIPSpro compiler and
  1625.                    the ----mmmmpppp option to compile the application.  This placement
  1626.                    option is not available with other compilers.
  1627.  
  1628.                *   The user must run the application on an Origin 300, Origin
  1629.                    3000, or Altix series server.
  1630.  
  1631.      To take full advantage of this placement option on IRIX systems, the user
  1632.      must be able to link the application such that the lllliiiibbbbmmmmppppiiii....ssssoooo iiiinnnniiiitttt code is
  1633.      run before the lllliiiibbbbmmmmpppp....ssssoooo iiiinnnniiiitttt code.  This is done by linking the
  1634.      MPI/OpenMP application as follows:
  1635.  
  1636.           cccccccc ----66664444 ----mmmmpppp ccccoooommmmppppuuuutttteeee____mmmmpppp....cccc ----llllmmmmpppp ----llllmmmmppppiiii
  1637.           ffff77777777 ----66664444 ----mmmmpppp ccccoooommmmppppuuuutttteeee____mmmmpppp....ffff ----llllmmmmpppp ----llllmmmmppppiiii
  1638.           ffff99990000 ----66664444 ----mmmmpppp ccccoooommmmppppuuuutttteeee____mmmmpppp....ffff ----llllmmmmpppp ----llllmmmmppppiiii
  1639.           CCCCCCCC ----66664444 ----mmmmpppp ccccoooommmmppppuuuutttteeee____mmmmpppp....CCCC ----llllmmmmpppp ----llllmmmmppppiiii++++++++ ----llllmmmmppppiiii
  1640.  
  1641.      This linkage order insures that the lllliiiibbbbmmmmppppiiii....ssssoooo iiiinnnniiiitttt runs procedures for
  1642.      restricting the placement of OpenMP threads before the lllliiiibbbbmmmmpppp....ssssoooo iiiinnnniiiitttt is
  1643.      run.  Note that this is not the default linkage if only the ----mmmmpppp option is
  1644.  
  1645.  
  1646.  
  1647.                                                                        PPPPaaaaggggeeee 22225555
  1648.  
  1649.  
  1650.  
  1651.  
  1652.  
  1653.  
  1654. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  1655.  
  1656.  
  1657.  
  1658.      specified on the link line.
  1659.  
  1660.      On IRIX systems, you can use an additional memory placement feature for
  1661.      hybrid MPI/OpenMP applications by using the MMMMPPPPIIII____DDDDSSSSMMMM____PPPPLLLLAAAACCCCEEEEMMMMEEEENNNNTTTT shell
  1662.      variable. Specification of a tttthhhhrrrreeeeaaaaddddrrrroooouuuunnnnddddrrrroooobbbbiiiinnnn policy results in the
  1663.      parent MPI process stack, data, and heap memory segments being spread
  1664.      across the nodes on which the child OpenMP threads are running.  For more
  1665.      information, see the EEEENNNNVVVVIIIIRRRROOOONNNNMMMMEEEENNNNTTTT VVVVAAAARRRRIIIIAAAABBBBLLLLEEEESSSS section of this man page.
  1666.  
  1667.      MPI reserves nodes for this hybrid placement model based on the number of
  1668.      MPI processes and the number of OpenMP threads per process, rounded up to
  1669.      the nearest multiple of 4 on IRIX systems and 2 on Altix systems.  For
  1670.      instance, on IRIX systems, if 6 OpenMP threads per MPI process are going
  1671.      to be used for a 4 MPI process job, MPI will request a placement for 32
  1672.      (4 X 8) CPUs on the host machine.  You should take this into account when
  1673.      requesting resources in a batch environment or when using ccccppppuuuusssseeeettttssss.  In
  1674.      this implementation, it is assumed that all MPI processes start with the
  1675.      same number of OpenMP threads, as specified by the OOOOMMMMPPPP____NNNNUUUUMMMM____TTTTHHHHRRRREEEEAAAADDDDSSSS or
  1676.      equivalent shell variable at job startup.
  1677.  
  1678.      NOTE:  This placement is not recommended when setting ____DDDDSSSSMMMM____PPPPPPPPMMMM to  a
  1679.      non-default value (for more information, see ppppeeee____eeeennnnvvvviiiirrrroooonnnn(5)).   This
  1680.      placement is also not recommended when running on a host with partially
  1681.      populated nodes.  Also, on IRIX systems, if you  are using
  1682.      MMMMPPPPIIII____DDDDSSSSMMMM____MMMMUUUUSSSSTTTTRRRRUUUUNNNN, it is important to also set ____DDDDSSSSMMMM____MMMMUUUUSSSSTTTTRRRRUUUUNNNN to properly
  1683.      schedule the OpenMP  threads.
  1684.  
  1685.      On Linux systems, the OpenMP threads are not actually pinned to specific
  1686.      CPUs but are limited to the set of CPUs near the MPI rank.  Actual
  1687.      pinning of the threads will be supported in a future release.
  1688.  
  1689. SSSSEEEEEEEE AAAALLLLSSSSOOOO
  1690.      mmmmppppiiiirrrruuuunnnn(1), sssshhhhmmmmeeeemmmm____iiiinnnnttttrrrroooo(1)
  1691.  
  1692.      aaaarrrrrrrraaaayyyydddd(1M)
  1693.  
  1694.      MMMMPPPPIIII____BBBBuuuuffffffffeeeerrrr____aaaattttttttaaaacccchhhh(3), MMMMPPPPIIII____BBBBuuuuffffffffeeeerrrr____ddddeeeettttaaaacccchhhh(3), MMMMPPPPIIII____IIIInnnniiiitttt(3), MMMMPPPPIIII____IIIIOOOO(3)
  1695.  
  1696.      aaaarrrrrrrraaaayyyydddd....ccccoooonnnnffff(4)
  1697.  
  1698.      aaaarrrrrrrraaaayyyy____sssseeeerrrrvvvviiiicccceeeessss(5)
  1699.  
  1700.      For more information about using MPI, including optimization, see the
  1701.      _M_e_s_s_a_g_e _P_a_s_s_i_n_g _T_o_o_l_k_i_t: _M_P_I _P_r_o_g_r_a_m_m_e_r'_s _M_a_n_u_a_l. You can access this
  1702.      manual online at hhhhttttttttpppp::::////////tttteeeecccchhhhppppuuuubbbbssss....ssssggggiiii....ccccoooommmm.
  1703.  
  1704.      Man pages exist for every MPI subroutine and function, as well as for the
  1705.      mmmmppppiiiirrrruuuunnnn(1) command.  Additional online information is available at
  1706.      hhhhttttttttpppp::::////////wwwwwwwwwwww....mmmmccccssss....aaaannnnllll....ggggoooovvvv////mmmmppppiiii, including a hypertext version of the
  1707.      standard, information on other libraries that use MPI, and pointers to
  1708.      other MPI resources.
  1709.  
  1710.  
  1711.  
  1712.  
  1713.                                                                        PPPPaaaaggggeeee 22226666
  1714.  
  1715.  
  1716.  
  1717.  
  1718.  
  1719.  
  1720. MMMMPPPPIIII((((1111))))                                                                  MMMMPPPPIIII((((1111))))
  1721.  
  1722.  
  1723.  
  1724.  
  1725.  
  1726.  
  1727.  
  1728.  
  1729.  
  1730.  
  1731.  
  1732.  
  1733.  
  1734.  
  1735.  
  1736.  
  1737.  
  1738.  
  1739.  
  1740.  
  1741.  
  1742.  
  1743.  
  1744.  
  1745.  
  1746.  
  1747.  
  1748.  
  1749.  
  1750.  
  1751.  
  1752.  
  1753.  
  1754.  
  1755.  
  1756.  
  1757.  
  1758.  
  1759.  
  1760.  
  1761.  
  1762.  
  1763.  
  1764.  
  1765.  
  1766.  
  1767.  
  1768.  
  1769.  
  1770.  
  1771.  
  1772.  
  1773.  
  1774.  
  1775.  
  1776.                                                                        PPPPaaaaggggeeee 22227777
  1777.  
  1778.  
  1779.  
  1780.  
  1781.  
  1782.  
  1783.